﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class GameplayPVEPveSceneWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(Gameplay.PVE.PveScene);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 68, 12, 12);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "RpgStart", _m_RpgStart_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "EnterScene", _m_EnterScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Init", _m_Init_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "EnterPveBattle", _m_EnterPveBattle_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateCardInfo", _m_UpdateCardInfo_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdatePveHeroes", _m_UpdatePveHeroes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdatePveCards", _m_UpdatePveCards_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnClickSkill", _m_OnClickSkill_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillTouchStart", _m_SkillTouchStart_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillTouchEnd", _m_SkillTouchEnd_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillDragStart", _m_SkillDragStart_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillDragEnd", _m_SkillDragEnd_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillDragOutEnd", _m_SkillDragOutEnd_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillDrag", _m_SkillDrag_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayCDAnimation", _m_PlayCDAnimation_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeSpeed", _m_ChangeSpeed_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeAuto", _m_ChangeAuto_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnClickHero", _m_OnClickHero_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnSlideHero", _m_OnSlideHero_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnClickUltra", _m_OnClickUltra_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Exit", _m_Exit_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginBlackFade", _m_BeginBlackFade_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgSummonConfig", _m_PreloadRpgSummonConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgObstacleConfig", _m_PreloadRpgObstacleConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgEffectConfig", _m_PreloadRpgEffectConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgHeroConfig", _m_PreloadRpgHeroConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgSkillConfig", _m_PreloadRpgSkillConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgBulletConfig", _m_PreloadRpgBulletConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgElementConfig", _m_PreloadRpgElementConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgWeaponConfig", _m_PreloadRpgWeaponConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgResourceConfig", _m_PreloadRpgResourceConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgNpcEventConfig", _m_PreloadRpgNpcEventConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgNpcDialogConfig", _m_PreloadRpgNpcDialogConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgNpcDialogContentConfig", _m_PreloadRpgNpcDialogContentConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgLevelMonsterConfig", _m_PreloadRpgLevelMonsterConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgModelPlaceConfig", _m_PreloadRpgModelPlaceConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgSpecialObjectConfig", _m_PreloadRpgSpecialObjectConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetRpgLevelId", _m_SetRpgLevelId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgMonsterConfig", _m_PreloadRpgMonsterConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadRpgModelConfig", _m_PreloadRpgModelConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadExternalHeroConfig", _m_PreloadExternalHeroConfig_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdatePveHeroAttributes", _m_UpdatePveHeroAttributes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdatePveMonsterAttributes", _m_UpdatePveMonsterAttributes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdatePveMonsterLevels", _m_UpdatePveMonsterLevels_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetIsTest", _m_SetIsTest_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "StartPveScene", _m_StartPveScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ResumeAfk", _m_ResumeAfk_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCameraEnable", _m_SetCameraEnable_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PauseAfk", _m_PauseAfk_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogicPause", _m_LogicPause_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogicResume", _m_LogicResume_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadLangConfigs", _m_PreloadLangConfigs_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPveCameraForward", _m_GetPveCameraForward_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPveCamera", _m_GetPveCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateRpgCostValue", _m_UpdateRpgCostValue_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HideAllHeroes", _m_HideAllHeroes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateRpgLevelTime", _m_UpdateRpgLevelTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCinemachineCameraStyleAndTime", _m_SetCinemachineCameraStyleAndTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCinemachineCameraFov", _m_SetCinemachineCameraFov_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCinemachineCameraNearClipPlane", _m_SetCinemachineCameraNearClipPlane_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCinemachineCameraFarClipPlane", _m_SetCinemachineCameraFarClipPlane_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetShaderTagZTestMode", _m_GetShaderTagZTestMode_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ResizeTextWithFixedWidthAndLine", _m_ResizeTextWithFixedWidthAndLine_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ResizeTextWidthMaxWidth", _m_ResizeTextWidthMaxWidth_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BornPositionCheck", _m_BornPositionCheck_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckAttachGround", _m_CheckAttachGround_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAttachGroundPoint", _m_GetAttachGroundPoint_xlua_st_);
            
			
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isInited", _g_get_isInited);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "pveRoot", _g_get_pveRoot);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "pveRootTrans", _g_get_pveRootTrans);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsTest", _g_get_IsTest);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsToRPG", _g_get_IsToRPG);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsToTurnBase", _g_get_IsToTurnBase);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsEditor", _g_get_IsEditor);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "heroCount", _g_get_heroCount);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isShowPveTestOnGUI", _g_get_isShowPveTestOnGUI);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsPassiveAllUnlock", _g_get_IsPassiveAllUnlock);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LevelId", _g_get_LevelId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isPause", _g_get_isPause);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isInited", _s_set_isInited);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "pveRoot", _s_set_pveRoot);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "pveRootTrans", _s_set_pveRootTrans);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsTest", _s_set_IsTest);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsToRPG", _s_set_IsToRPG);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsToTurnBase", _s_set_IsToTurnBase);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsEditor", _s_set_IsEditor);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "heroCount", _s_set_heroCount);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isShowPveTestOnGUI", _s_set_isShowPveTestOnGUI);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsPassiveAllUnlock", _s_set_IsPassiveAllUnlock);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LevelId", _s_set_LevelId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isPause", _s_set_isPause);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new Gameplay.PVE.PveScene();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveScene constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new Gameplay.PVE.PveScene();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveScene constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RpgStart_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = Gameplay.PVE.PveScene.RpgStart(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_EnterScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.EnterScene(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.Init(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_EnterPveBattle_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.EnterPveBattle(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateCardInfo_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdateCardInfo( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePveHeroes_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdatePveHeroes( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePveCards_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdatePveCards( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnClickSkill_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.OnClickSkill( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillTouchStart_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    UnityEngine.GameObject _card = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject));
                    
                    Gameplay.PVE.PveScene.SkillTouchStart( _id, _card );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillTouchEnd_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    UnityEngine.GameObject _card = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject));
                    
                    Gameplay.PVE.PveScene.SkillTouchEnd( _id, _card );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillDragStart_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    UnityEngine.Vector2 _position;translator.Get(L, 2, out _position);
                    
                    Gameplay.PVE.PveScene.SkillDragStart( _id, _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillDragEnd_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.SkillDragEnd( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillDragOutEnd_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.SkillDragOutEnd( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SkillDrag_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    UnityEngine.Vector2 _position;translator.Get(L, 2, out _position);
                    
                    Gameplay.PVE.PveScene.SkillDrag( _id, _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayCDAnimation_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.PlayCDAnimation( _index );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ChangeSpeed_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _speed = (float)LuaAPI.lua_tonumber(L, 1);
                    
                    Gameplay.PVE.PveScene.ChangeSpeed( _speed );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ChangeAuto_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isAuto = LuaAPI.lua_toboolean(L, 1);
                    
                    Gameplay.PVE.PveScene.ChangeAuto( _isAuto );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnClickHero_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.OnClickHero( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnSlideHero_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.OnSlideHero( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnClickUltra_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.OnClickUltra(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Exit_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.Exit(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BeginBlackFade_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    float _startAlpha = (float)LuaAPI.lua_tonumber(L, 1);
                    float _endAlpha = (float)LuaAPI.lua_tonumber(L, 2);
                    float _fadeTime = (float)LuaAPI.lua_tonumber(L, 3);
                    XLua.LuaFunction _function = (XLua.LuaFunction)translator.GetObject(L, 4, typeof(XLua.LuaFunction));
                    
                    Gameplay.PVE.PveScene.BeginBlackFade( _startAlpha, _endAlpha, _fadeTime, _function );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgSummonConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgSummonConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgObstacleConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgObstacleConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgEffectConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgEffectConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgHeroConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgHeroConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgSkillConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgSkillConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgBulletConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgBulletConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgElementConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgElementConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgWeaponConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgWeaponConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgResourceConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgResourceConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgNpcEventConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgNpcEventConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgNpcDialogConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgNpcDialogConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgNpcDialogContentConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgNpcDialogContentConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgLevelMonsterConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgLevelMonsterConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgModelPlaceConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgModelPlaceConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgSpecialObjectConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgSpecialObjectConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetRpgLevelId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _levelId = LuaAPI.xlua_tointeger(L, 1);
                    bool _isInitialize = LuaAPI.lua_toboolean(L, 2);
                    
                    Gameplay.PVE.PveScene.SetRpgLevelId( _levelId, _isInitialize );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _levelId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.SetRpgLevelId( _levelId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveScene.SetRpgLevelId!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgMonsterConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgMonsterConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadRpgModelConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadRpgModelConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadExternalHeroConfig_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadExternalHeroConfig( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePveHeroAttributes_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdatePveHeroAttributes( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePveMonsterAttributes_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdatePveMonsterAttributes( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePveMonsterLevels_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.UpdatePveMonsterLevels( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsTest_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isTest = LuaAPI.lua_toboolean(L, 1);
                    
                    Gameplay.PVE.PveScene.SetIsTest( _isTest );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StartPveScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.StartPveScene(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResumeAfk_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.ResumeAfk(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCameraEnable_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.SetCameraEnable(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PauseAfk_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.PauseAfk(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LogicPause_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.LogicPause(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LogicResume_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.LogicResume(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadLangConfigs_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaTable _table = (XLua.LuaTable)translator.GetObject(L, 1, typeof(XLua.LuaTable));
                    
                    Gameplay.PVE.PveScene.PreloadLangConfigs( _table );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPveCameraForward_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = Gameplay.PVE.PveScene.GetPveCameraForward(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPveCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = Gameplay.PVE.PveScene.GetPveCamera(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateRpgCostValue_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _init = (float)LuaAPI.lua_tonumber(L, 1);
                    float _recovery = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Gameplay.PVE.PveScene.UpdateRpgCostValue( _init, _recovery );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HideAllHeroes_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Gameplay.PVE.PveScene.HideAllHeroes(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateRpgLevelTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _time = LuaAPI.xlua_tointeger(L, 1);
                    
                    Gameplay.PVE.PveScene.UpdateRpgLevelTime( _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCinemachineCameraStyleAndTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Cinemachine.CinemachineBrain _brain = (Cinemachine.CinemachineBrain)translator.GetObject(L, 1, typeof(Cinemachine.CinemachineBrain));
                    int _style = LuaAPI.xlua_tointeger(L, 2);
                    float _time = (float)LuaAPI.lua_tonumber(L, 3);
                    
                    Gameplay.PVE.PveScene.SetCinemachineCameraStyleAndTime( _brain, _style, _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCinemachineCameraFov_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Cinemachine.CinemachineVirtualCamera _camera = (Cinemachine.CinemachineVirtualCamera)translator.GetObject(L, 1, typeof(Cinemachine.CinemachineVirtualCamera));
                    float _fov = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Gameplay.PVE.PveScene.SetCinemachineCameraFov( _camera, _fov );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCinemachineCameraNearClipPlane_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Cinemachine.CinemachineVirtualCamera _camera = (Cinemachine.CinemachineVirtualCamera)translator.GetObject(L, 1, typeof(Cinemachine.CinemachineVirtualCamera));
                    float _near = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Gameplay.PVE.PveScene.SetCinemachineCameraNearClipPlane( _camera, _near );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCinemachineCameraFarClipPlane_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Cinemachine.CinemachineVirtualCamera _camera = (Cinemachine.CinemachineVirtualCamera)translator.GetObject(L, 1, typeof(Cinemachine.CinemachineVirtualCamera));
                    float _far = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Gameplay.PVE.PveScene.SetCinemachineCameraFarClipPlane( _camera, _far );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetShaderTagZTestMode_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = Gameplay.PVE.PveScene.GetShaderTagZTestMode(  );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResizeTextWithFixedWidthAndLine_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.RectTransform _rectTransform = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform));
                    float _fixedWidth = (float)LuaAPI.lua_tonumber(L, 2);
                    int _line = LuaAPI.xlua_tointeger(L, 3);
                    
                    Gameplay.PVE.PveScene.ResizeTextWithFixedWidthAndLine( _rectTransform, _fixedWidth, _line );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResizeTextWidthMaxWidth_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.RectTransform _rectTransform = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform));
                    float _fixedWidth = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Gameplay.PVE.PveScene.ResizeTextWidthMaxWidth( _rectTransform, _fixedWidth );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BornPositionCheck_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _path = LuaAPI.lua_tostring(L, 1);
                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
                    UnityEngine.Vector3 _forward;translator.Get(L, 3, out _forward);
                    
                    Gameplay.PVE.PveScene.BornPositionCheck( _path, _position, _forward );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckAttachGround_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Transform>(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    UnityEngine.Transform _point = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform));
                    bool _showLog = LuaAPI.lua_toboolean(L, 2);
                    
                    Gameplay.PVE.PveScene.CheckAttachGround( _point, _showLog );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& translator.Assignable<UnityEngine.Transform>(L, 1)) 
                {
                    UnityEngine.Transform _point = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform));
                    
                    Gameplay.PVE.PveScene.CheckAttachGround( _point );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveScene.CheckAttachGround!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAttachGroundPoint_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    string _name = LuaAPI.lua_tostring(L, 2);
                    
                        var gen_ret = Gameplay.PVE.PveScene.GetAttachGroundPoint( _position, _name );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& translator.Assignable<UnityEngine.Vector3>(L, 1)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    
                        var gen_ret = Gameplay.PVE.PveScene.GetAttachGroundPoint( _position );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.PveScene.GetAttachGroundPoint!");
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInited(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.isInited);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_pveRoot(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.PveScene.pveRoot);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_pveRootTrans(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.PveScene.pveRootTrans);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsTest(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.IsTest);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsToRPG(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.IsToRPG);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsToTurnBase(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.IsToTurnBase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsEditor(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.IsEditor);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_heroCount(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveScene.heroCount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isShowPveTestOnGUI(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.isShowPveTestOnGUI);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsPassiveAllUnlock(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.IsPassiveAllUnlock);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_LevelId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.PveScene.LevelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isPause(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.PveScene.isPause);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInited(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.isInited = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_pveRoot(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Gameplay.PVE.PveScene.pveRoot = (UnityEngine.GameObject)translator.GetObject(L, 1, typeof(UnityEngine.GameObject));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_pveRootTrans(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Gameplay.PVE.PveScene.pveRootTrans = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsTest(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.IsTest = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsToRPG(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.IsToRPG = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsToTurnBase(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.IsToTurnBase = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsEditor(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.IsEditor = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_heroCount(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.heroCount = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isShowPveTestOnGUI(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.isShowPveTestOnGUI = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsPassiveAllUnlock(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.IsPassiveAllUnlock = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_LevelId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.LevelId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isPause(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.PveScene.isPause = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
